// pages/settings/settings.js
// 导入 CommandManager
import CommandManager from '../../utils/commandManager';

Page({

  /**
   * 页面的初始数据
   */
  data: {
    macAddress: '00:11:22:33:44:55', // MAC地址
    firmwareVersion: 'v1.0.0',    // 固件版本
    childLockEnabled: false,      // 儿童安全锁状态
    ledEnabled: false,           // LED指示灯状态
    powerOnState: 0,            // 断电后通电状态(0:记忆, 1:开启, 2:关闭)
    powerOnStateOptions: ['记忆', '开启', '关闭'], // 通电状态选项
    showPowerOnStateDialog: false, // 是否显示断电后通电状态选择弹窗
    tempPowerOnState: 0,         // 临时存储选择的状态
    electricityPrice: '0.55',     // 电价（元/度）
    udpManager: null,              // 添加 UDP 管理器
    wifiConfig: {
      ssid: '',
      password: ''
    },
    mqttConfig: {
      url: '',
      username: '',
      password: '',
      clientId: '',
      upTopic: '',
      downTopic: '',
      otaTopic: ''
    },
    otaConfig: {
      updateUrl: ''
    },
    deviceInfo: null,  // 添加设备信息字段
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {

  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 从全局数据获取 UDP 管理器
    const udpManager = getApp().globalData.udpManager;
    
    if (udpManager) {
      console.log('[设置] 从全局数据获取 UDP 管理器');
      this.setData({ udpManager });
      
      // 注册消息处理器
      this.registerMessageHandlers();
      
      // 查询设备状态
      this.queryChildLockState();
      this.queryLEDState();
      this.queryPowerOnState();
    } else {
      console.error('[设置] 无法获取 UDP 管理器');
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
    }

    // 从全局状态获取设备信息
    const deviceInfo = getApp().globalData.deviceInfo
    if (deviceInfo) {
      this.setData({
        deviceInfo
      })
    }

    this.queryConfig();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    // 清理消息处理器
    if (this.data.udpManager) {
      this.data.udpManager.clearMessageHandlers();
      console.log('[设置] 已清理消息处理器');
    }
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 检查更新
  async checkUpdate() {
    const app = getApp();
    const currentVersion = this.data.deviceInfo?.version;
    const otaUrl = app.globalData.otaConfig?.updateUrl;

    if (!otaUrl) {
      wx.showToast({
        title: '未配置OTA服务器',
        icon: 'none'
      });
      return;
    }

    if (!currentVersion) {
      wx.showToast({
        title: '获取版本信息失败',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '检查更新中...'
    });

    try {
      console.log('[设置] 开始检查更新，OTA服务器地址:', otaUrl);
      
      // 获取OTA服务器上的固件列表
      const response = await new Promise((resolve, reject) => {
        wx.request({
          url: otaUrl,
          method: 'GET',
          header: {
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
          },
          success: (res) => {
            console.log('[设置] 请求成功，状态码:', res.statusCode);
            console.log('[设置] 响应头:', res.header);
            resolve(res);
          },
          fail: (err) => {
            console.error('[设置] 请求失败:', err);
            reject(new Error('请求失败: ' + (err.errMsg || '未知错误')));
          }
        });
      });

      if (!response) {
        throw new Error('请求失败: 无响应');
      }

      if (response.statusCode !== 200) {
        throw new Error(`请求失败: 状态码 ${response.statusCode}`);
      }

      if (!response.data) {
        throw new Error('获取固件列表失败: 服务器返回数据为空');
      }

      console.log('[设置] 服务器返回数据:', response.data);

      // 从HTML响应中提取文件列表
      const htmlContent = response.data;
      const files = [];
      
      // 使用正则表达式匹配所有文件链接
      const filePattern = /<a href="([^"]+)">/g;
      let match;
      
      while ((match = filePattern.exec(htmlContent)) !== null) {
        const fileName = match[1];
        // 只添加.bin文件
        if (fileName.endsWith('.bin')) {
          files.push(fileName);
        }
      }

      console.log('[设置] 解析到的固件文件:', files);

      if (files.length === 0) {
        throw new Error('未找到固件文件');
      }

      // 解析固件列表,查找最新版本
      const versionRegex = /smart-socket_v(\d+)_(\d+)_(\d+)\.bin/;
      let latestVersion = currentVersion;
      let latestFile = null;

      for (const file of files) {
        const match = versionRegex.exec(file);
        if (match) {
          const version = `${match[1]}.${match[2]}.${match[3]}`;
          console.log('[设置] 找到版本:', version);
          if (this.compareVersions(version, latestVersion) > 0) {
            latestVersion = version;
            latestFile = file;
          }
        }
      }

      wx.hideLoading();

      if (!latestFile) {
        wx.showToast({
          title: '已是最新版本',
          icon: 'success'
        });
        return;
      }

      // 提示用户是否更新
      const confirmResult = await wx.showModal({
        title: '发现新版本',
        content: `当前版本: ${currentVersion}\n最新版本: ${latestVersion}\n是否更新?`,
        confirmText: '更新',
        cancelText: '取消'
      });

      if (confirmResult.confirm) {
        // 确保URL以/结尾
        const baseUrl = otaUrl.endsWith('/') ? otaUrl : otaUrl + '/';
        await this.startOTAUpdate(baseUrl + latestFile);
      }

    } catch (error) {
      console.error('[设置] 检查更新失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '检查更新失败',
        icon: 'none'
      });
    }
  },

  // 比较版本号
  compareVersions(v1, v2) {
    const parts1 = v1.split('.').map(Number);
    const parts2 = v2.split('.').map(Number);
    
    for (let i = 0; i < 3; i++) {
      if (parts1[i] > parts2[i]) return 1;
      if (parts1[i] < parts2[i]) return -1;
    }
    
    return 0;
  },

  // 开始OTA更新
  async startOTAUpdate(firmwareUrl) {
    const udpManager = getApp().globalData.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '正在发送更新...'
    });

    try {
      const frame = CommandManager.createOTAUpdateCommand(firmwareUrl);
      
      if (!frame) {
        throw new Error('创建更新命令失败');
      }

      const response = await udpManager.sendAndWait(frame, 3000);
      
      const result = CommandManager.parseFrame(response);
      if (!result || !result.data || !result.data.success) {
        throw new Error('设备响应失败');
      }

      wx.hideLoading();
      wx.showModal({
        title: '更新提示',
        content: '更新指令已发送,设备将自动重启并更新,请耐心等待...',
        showCancel: false
      });

    } catch (error) {
      console.error('[设置] 发送更新命令失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: '发送更新命令失败',
        icon: 'none'
      });
    }
  },

  // 恢复出厂设置
  resetDevice() {
    // 添加日志
    console.log('[设置] 开始恢复出厂设置');
    
    wx.showModal({
      title: '警告',
      content: '确定要恢复出厂设置吗？此操作不可撤销。',
      confirmText: '确定',
      confirmColor: '#ff3b30',
      success: (res) => {
        // 添加日志
        console.log('[设置] 确认对话框结果:', res);
        
        if (res.confirm) {
          wx.showLoading({
            title: '正在重置...',
          });
          
          // 添加日志
          console.log('[设置] 创建恢复出厂设置命令');
          
          // 创建并发送恢复出厂设置命令
          const frame = CommandManager.createFactoryResetCommand();
          if (!frame) {
            console.error('[设置] 创建恢复出厂设置命令失败');
            wx.hideLoading();
            wx.showToast({
              title: '操作失败',
              icon: 'error'
            });
            return;
          }

          // 使用保存的 UDP 管理器
          const udpManager = this.data.udpManager;
          if (!udpManager || !udpManager.isConnected) {
            console.error('[设置] UDP 未连接');
            wx.hideLoading();
            wx.showToast({
              title: '设备未连接',
              icon: 'error'
            });
            return;
          }

          // 添加日志
          console.log('[设置] 发送恢复出厂设置命令');

          // 发送命令并等待响应
          udpManager.sendAndWait(frame)
            .then(response => {
              console.log('[设置] 收到响应:', response);
              const result = CommandManager.parseFrame(response);
              if (!result || !result.data.success) {
                throw new Error('设备返回失败');
              }
              
              wx.hideLoading();
              wx.showModal({
                title: '重置成功',
                content: '设备已恢复出厂设置，需要重新搜索并连接设备。',
                showCancel: false,
                success: () => {
                  // 重置后返回首页
                  wx.switchTab({
                    url: '/pages/index/index'
                  });
                }
              });
            })
            .catch(err => {
              console.error('[设置] 恢复出厂设置失败:', err);
              wx.hideLoading();
              wx.showModal({
                title: '重置失败',
                content: err.message || '请检查设备连接后重试',
                showCancel: false
              });
            });
        }
      }
    });
  },

  // 空方法，点击时不执行任何操作
  doNothing() {
    // 什么都不做
  },

  // 跳转到"我的"页面
  goToMinePage() {
    wx.navigateTo({
      url: '/pages/mine/mine'
    });
  },

  // 注册消息处理器
  registerMessageHandlers() {
    const udpManager = this.data.udpManager;
    if (!udpManager) return;
    
    // 清除可能存在的旧处理器
    udpManager.clearMessageHandlers();
    
    // 注册新的消息处理器
    udpManager.onMessage((data) => {
      console.log('[设置] 收到消息:', Array.from(data).map(b => b.toString(16).padStart(2, '0')).join(' '));
      
      // 解析响应
      const result = CommandManager.parseFrame(data);
      if (!result) {
        console.warn('[设置] 无法解析响应数据');
        return;
      }
      
      console.log('[设置] 解析结果:', result);
      
      // 根据命令类型处理响应
      switch (result.cmd) {
        case 0x0C: // 查询儿童安全锁
          if (result.data && result.data.state !== undefined) {
            this.setData({
              childLockEnabled: result.data.state === 1
            });
            console.log('[设置] 更新儿童安全锁状态:', result.data.state);
          }
          break;
          
        case 0x0E: // 查询LED状态
          if (result.data && result.data.state !== undefined) {
            this.setData({
              ledEnabled: result.data.state === 1
            });
            console.log('[设置] 更新LED状态:', result.data.state);
          }
          break;
          
        case 0x10: // 查询断电后通电状态
          if (result.data && result.data.state !== undefined) {
            this.setData({
              powerOnState: result.data.state
            });
            console.log('[设置] 更新断电后通电状态:', result.data.state);
          }
          break;

        case 0x11: // 查询配置
          if (result.data) {
            // 详细打印每个配置项
            console.log('[设置] 配置数据:');
            console.log('WiFi配置:');
            console.log('- SSID:', result.data.ssid);
            console.log('- 密码:', result.data.pwd);
            console.log('MQTT配置:');
            console.log('- 服务器地址:', result.data.mqtt_url);
            console.log('- 用户名:', result.data.mqtt_username);
            console.log('- 密码:', result.data.mqtt_pwd);
            console.log('- 客户端ID:', result.data.mqtt_client_id);
            console.log('- 下行主题:', result.data.mqtt_down_topic);
            console.log('- 上行主题:', result.data.mqtt_up_topic);
            console.log('- OTA主题:', result.data.mqtt_ota_topic);
            console.log('OTA配置:');
            console.log('- 服务器地址:', result.data.ota_server_url);
            
            // 更新配置数据
            this.setData({
              wifiConfig: {
                ssid: result.data.ssid || '',
                password: result.data.pwd || ''
              },
              mqttConfig: {
                url: result.data.mqtt_url || '',
                username: result.data.mqtt_username || '',
                password: result.data.mqtt_pwd || '',
                clientId: result.data.mqtt_client_id || '',
                downTopic: result.data.mqtt_down_topic || '',
                upTopic: result.data.mqtt_up_topic || '',
                otaTopic: result.data.mqtt_ota_topic || ''
              },
              otaConfig: {
                updateUrl: result.data.ota_server_url || ''
              }
            });

            // 保存配置到全局变量
            getApp().globalData.wifiConfig = this.data.wifiConfig;
            getApp().globalData.mqttConfig = this.data.mqttConfig;
            getApp().globalData.otaConfig = this.data.otaConfig;
          }
          break;
          
        case 0x0B: // 设置儿童安全锁
          this.handleSetResponse('CHILD_LOCK', result.data);
          break;
          
        case 0x0D: // 设置LED状态
          this.handleSetResponse('LED', result.data);
          break;
          
        case 0x0F: // 设置断电后通电状态
          this.handleSetResponse('POWER_ON_STATE', result.data);
          break;

        case 0x12: // 设置配置
          this.handleSetResponse('CONFIG', result.data);
          break;
          
        default:
          console.warn('[设置] 未处理的命令类型:', result.cmd);
      }
    });
    
    console.log('[设置] 已注册消息处理器');
  },

  // 处理设置响应
  handleSetResponse(type, data) {
    // 清除超时定时器
    if (this.currentOperation && this.currentOperation.timeoutId) {
      clearTimeout(this.currentOperation.timeoutId);
    }
    
    // 隐藏加载提示
    wx.hideLoading();
    
    if (!data || data.success === undefined) {
      console.warn(`[设置] ${type} 响应数据无效:`, data);
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      });
      return;
    }
    
    console.log(`[设置] ${type} 设置结果:`, data.success);
    
    if (data.success) {
      // 设置成功
      wx.showToast({
        title: '设置成功',
        icon: 'success'
      });
      
      // 对于断电后通电状态，关闭弹窗
      if (type === 'POWER_ON_STATE' && this.data.showPowerOnStateDialog) {
        this.setData({
          showPowerOnStateDialog: false
        });
      }
    } else {
      // 设置失败，恢复原状态
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      });
      
      // 恢复原状态
      if (this.currentOperation) {
        switch (type) {
          case 'CHILD_LOCK':
            this.setData({
              childLockEnabled: !this.currentOperation.state
            });
            break;
          case 'LED':
            this.setData({
              ledEnabled: !this.currentOperation.state
            });
            break;
          case 'POWER_ON_STATE':
            // 不关闭弹窗，让用户可以重试
            break;
          case 'CONFIG':
            // 配置设置失败不需要恢复，因为配置项太多
            break;
        }
      }
    }
    
    // 清除当前操作
    this.currentOperation = null;
  },

  // 查询儿童安全锁状态
  queryChildLockState() {
    console.log('[设置] 查询儿童安全锁状态');
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      return;
    }
    
    const frame = CommandManager.createQueryChildLockCommand();
    if (!frame) {
      console.error('[设置] 创建查询命令失败');
      return;
    }
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 查询儿童安全锁命令已发送');
      })
      .catch(err => {
        console.error('[设置] 查询儿童安全锁失败:', err);
      });
  },

  // 查询LED状态
  queryLEDState() {
    console.log('[设置] 查询LED状态');
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      return;
    }
    
    const frame = CommandManager.createQueryLEDStateCommand();
    if (!frame) {
      console.error('[设置] 创建查询命令失败');
      return;
    }
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 查询LED状态命令已发送');
      })
      .catch(err => {
        console.error('[设置] 查询LED状态失败:', err);
      });
  },

  // 查询断电后通电状态
  queryPowerOnState() {
    console.log('[设置] 查询断电后通电状态');
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      return;
    }
    
    const frame = CommandManager.createQueryPowerOnStateCommand();
    if (!frame) {
      console.error('[设置] 创建查询命令失败');
      return;
    }
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 查询断电后通电状态命令已发送');
      })
      .catch(err => {
        console.error('[设置] 查询断电后通电状态失败:', err);
      });
  },

  // 切换儿童安全锁状态
  toggleChildLock(e) {
    const newState = e.detail.value;
    console.log('[设置] 切换儿童安全锁状态:', newState);
    
    const frame = CommandManager.createSetChildLockCommand(newState);
    if (!frame) {
      console.error('[设置] 创建命令失败');
      return;
    }
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'error'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在设置...'
    });
    
    // 乐观更新UI
    this.setData({
      childLockEnabled: newState
    });
    
    // 设置超时定时器
    const timeoutId = setTimeout(() => {
      console.warn('[设置] 儿童安全锁设置超时');
      wx.hideLoading();
      wx.showToast({
        title: '设置超时',
        icon: 'error'
      });
    }, 5000); // 5秒超时
    
    // 标记当前操作
    this.currentOperation = {
      type: 'CHILD_LOCK',
      state: newState,
      timeoutId: timeoutId
    };
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 儿童安全锁命令已发送');
      })
      .catch(err => {
        console.error('[设置] 设置儿童安全锁失败:', err);
        // 清除超时定时器
        clearTimeout(timeoutId);
        this.currentOperation = null;
        
        // 恢复原状态
        this.setData({
          childLockEnabled: !newState
        });
        
        wx.hideLoading();
        wx.showToast({
          title: '设置失败',
          icon: 'error'
        });
      });
  },

  // 显示断电后通电状态选择弹窗
  showPowerOnStateDialog() {
    this.setData({
      showPowerOnStateDialog: true,
      tempPowerOnState: this.data.powerOnState // 初始化临时状态
    });
  },

  // 隐藏断电后通电状态选择弹窗
  hidePowerOnStateDialog() {
    this.setData({
      showPowerOnStateDialog: false
    });
  },

  // 防止点击内容区域触发关闭
  preventBubble() {
    return;
  },

  // 选择断电后通电状态
  selectPowerOnState(e) {
    const value = parseInt(e.currentTarget.dataset.value);
    this.setData({
      tempPowerOnState: value
    });
  },

  // 确认断电后通电状态设置
  confirmPowerOnState() {
    const newState = this.data.tempPowerOnState;
    console.log('[设置] 确认断电后通电状态:', newState);
    
    const frame = CommandManager.createSetPowerOnStateCommand(newState);
    if (!frame) {
      console.error('[设置] 创建命令失败');
      return;
    }
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'error'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在设置...'
    });
    
    // 设置超时定时器
    const timeoutId = setTimeout(() => {
      console.warn('[设置] 断电后通电状态设置超时');
      wx.hideLoading();
      wx.showToast({
        title: '设置超时',
        icon: 'error'
      });
    }, 5000); // 5秒超时
    
    // 标记当前操作
    this.currentOperation = {
      type: 'POWER_ON_STATE',
      state: newState,
      timeoutId: timeoutId
    };
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 断电后通电状态命令已发送');
        // 乐观更新UI，但不关闭弹窗，等待响应
        this.setData({
          powerOnState: newState
        });
      })
      .catch(err => {
        console.error('[设置] 设置断电后通电状态失败:', err);
        // 清除超时定时器
        clearTimeout(timeoutId);
        this.currentOperation = null;
        
        wx.hideLoading();
        wx.showToast({
          title: '设置失败',
          icon: 'error'
        });
        // 不关闭弹窗，让用户可以重试
      });
  },

  // 切换LED状态
  toggleLED(e) {
    const newState = e.detail.value;
    console.log('[设置] 切换LED状态:', newState);
    
    const frame = CommandManager.createSetLEDStateCommand(newState);
    if (!frame) {
      console.error('[设置] 创建命令失败');
      return;
    }
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'error'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在设置...'
    });
    
    // 乐观更新UI
    this.setData({
      ledEnabled: newState
    });
    
    // 设置超时定时器
    const timeoutId = setTimeout(() => {
      console.warn('[设置] LED状态设置超时');
      wx.hideLoading();
      wx.showToast({
        title: '设置超时',
        icon: 'error'
      });
    }, 5000); // 5秒超时
    
    // 标记当前操作
    this.currentOperation = {
      type: 'LED',
      state: newState,
      timeoutId: timeoutId
    };
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] LED状态命令已发送');
      })
      .catch(err => {
        console.error('[设置] 设置LED状态失败:', err);
        // 清除超时定时器
        clearTimeout(timeoutId);
        this.currentOperation = null;
        
        // 恢复原状态
        this.setData({
          ledEnabled: !newState
        });
        
        wx.hideLoading();
        wx.showToast({
          title: '设置失败',
          icon: 'error'
        });
      });
  },

  // 查询配置
  queryConfig() {
    console.log('[设置] 查询配置');
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'error'
      });
      return;
    }
    
    const frame = CommandManager.createQueryConfigCommand();
    if (!frame) {
      console.error('[设置] 创建查询命令失败');
      return;
    }
    
    // 直接发送命令，不等待响应
    udpManager.send(frame)
      .then(() => {
        console.log('[设置] 查询命令已发送');
      })
      .catch(err => {
        console.error('[设置] 发送查询命令失败:', err);
      });
  },

  // 保存配置
  saveConfig() {
    console.log('[设置] 保存配置');
    
    const udpManager = this.data.udpManager;
    if (!udpManager || !udpManager.isConnected) {
      console.error('[设置] UDP 未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'error'
      });
      return;
    }
    
    // 构建配置对象
    const config = {
      ssid: this.data.wifiConfig.ssid,
      pwd: this.data.wifiConfig.pwd,
      mqtt_url: this.data.mqttConfig.url,
      mqtt_username: this.data.mqttConfig.username,
      mqtt_pwd: this.data.mqttConfig.password,
      mqtt_client_id: this.data.mqttConfig.clientId,
      mqtt_down_topic: this.data.mqttConfig.downTopic,
      mqtt_up_topic: this.data.mqttConfig.upTopic,
      mqtt_ota_topic: this.data.mqttConfig.otaTopic,
      ota_server_url: this.data.otaConfig.url
    };
    
    // 详细打印要发送的配置
    console.log('[设置] 发送配置:');
    console.log('WiFi配置:');
    console.log('- SSID:', config.ssid);
    console.log('- 密码:', config.pwd);
    console.log('MQTT配置:');
    console.log('- 服务器地址:', config.mqtt_url);
    console.log('- 用户名:', config.mqtt_username);
    console.log('- 密码:', config.mqtt_pwd);
    console.log('- 客户端ID:', config.mqtt_client_id);
    console.log('- 下行主题:', config.mqtt_down_topic);
    console.log('- 上行主题:', config.mqtt_up_topic);
    console.log('- OTA主题:', config.mqtt_ota_topic);
    console.log('OTA配置:');
    console.log('- 服务器地址:', config.ota_server_url);
    
    const frame = CommandManager.createSetConfigCommand(config);
    if (!frame) {
      console.error('[设置] 创建设置命令失败');
      return;
    }
    
    wx.showLoading({
      title: '保存中...'
    });
    
    udpManager.sendAndWait(frame)
      .then(response => {
        // 将Uint8Array转换为十六进制字符串显示
        const hexStr = Array.from(response).map(b => b.toString(16).padStart(2, '0')).join(' ');
        console.log('[设置] 收到响应:', hexStr);
        
        const result = CommandManager.parseFrame(response);
        if (!result || !result.data || !result.data.success) {
          throw new Error('设置失败');
        }
        
        wx.hideLoading();
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        });
      })
      .catch(err => {
        console.error('[设置] 保存配置失败:', err);
        wx.hideLoading();
        wx.showToast({
          title: '保存失败',
          icon: 'error'
        });
      });
  },

  // 更新WiFi配置
  updateWifiSsid(e) {
    this.setData({
      'wifiConfig.ssid': e.detail.value
    });
  },

  updateWifiPwd(e) {
    this.setData({
      'wifiConfig.pwd': e.detail.value
    });
  },

  // 更新MQTT配置
  updateMqttUrl(e) {
    this.setData({
      'mqttConfig.url': e.detail.value
    });
  },

  updateMqttUsername(e) {
    this.setData({
      'mqttConfig.username': e.detail.value
    });
  },

  updateMqttPwd(e) {
    this.setData({
      'mqttConfig.password': e.detail.value
    });
  },

  updateMqttClientId(e) {
    this.setData({
      'mqttConfig.clientId': e.detail.value
    });
  },

  updateMqttDownTopic(e) {
    this.setData({
      'mqttConfig.downTopic': e.detail.value
    });
  },

  updateMqttUpTopic(e) {
    this.setData({
      'mqttConfig.upTopic': e.detail.value
    });
  },

  updateMqttOtaTopic(e) {
    this.setData({
      'mqttConfig.otaTopic': e.detail.value
    });
  },

  // 更新OTA配置
  updateOtaUrl(e) {
    this.setData({
      'otaConfig.url': e.detail.value
    });
  },

  // 打开设备配置页面
  openDeviceConfig() {
    wx.navigateTo({
      url: './config/config',
      fail: (err) => {
        console.error('[导航] 打开设备配置页面失败:', err);
        wx.showToast({
          title: '打开配置页面失败',
          icon: 'none'
        });
      }
    });
  }
})